Awesome Naming
      
    
    
    
      Famously…
      
    
    
      
        There are only two hard things in Computer Science: cache invalidation
        and naming things.
      
      ― Phil Karlton
    
    
      Concepts in computer science are usually nothing tangible so it’s no
      surprise that naming things is hard. Nevertheless, we do come up
      with clever, creative and funny names. Some of them so established, we
      never pause and admire.
    
    This is a curated list for when naming things is done right.
    Contents
    
    
    Data Structures and Algorithms
    
      - 
        Brute force
        - Violence is actually almost always a solution but not a very clever
        one.
      
 
      - 
        Greedy algorithm
        - An algorithm that finds a solution by always picking the currently
        best looking option without thinking too much about past and future
        decisions.
      
 
      - 
        Hill climbing
        - Starting somewhere in the hilly “landscape” of solutions you go in the
        direction of steepest ascent until reaching the top of a hill. You might
        miss higher hills though.
      
 
      - 
        Israeli Queue
        - A type of priority queue and a reference to the infamously unorganized
        queues in Israel. Here items can cut in line when they
        have already waiting friends.
      
 
      - 
        Stack
        - Like with a stack of pancakes you can only add and remove items from
        the top of this data structure.
      
 
      - 
        Tree -
        A hierarchically organized data structure. From the root item
        the other items branch out into nodes and
        leaves.
      
 
      - 
        Queue
        - In this data structure items are always added at the end and removed
        at the front as if the items were waiting in line.
      
 
    
    
      Design Patterns and Anti Patterns
    
    
      - 
        Adapter -
        Allows classes with incompatible interfaces to work together by wrapping
        its own interface around that of an already existing class.
      
 
      - 
        Facade -
        Analogous to a facade in architecture, a facade is an object that serves
        as a front-facing interface masking more complex underlying structure.
      
 
      - 
        Promise
        - A representation of a result that is available in the future, unless
        there are errors. Like in reality, promises are broken sometimes.
      
 
      - 
        Shotgun surgery
        - A programming anitpattern where in a single change you wildly add code
        everywhere in your codebase.
      
 
    
    Functions
    
      - 
        fold
        - Like a blanket being folded up, this function iterates a collection
        and in each step combines the current item with everything that has
        already been folded.
      
 
      - 
        trampoline
        - Continuously runs functions which itself return functions. Like a
        child on a trampoline that returns and bounces back up.
      
 
      - 
        zip
        - Merges two lists into one list of pairs like the interlocking teeth of
        a zipper.
      
 
    
    IT Security
    
      - 
        Backdoor
        - A method of bypassing normal authentication in a computer system.
      
 
      - 
        Computer virus
        - A computer program that self replicates by infecting other
        computer programs similar to the behavior of biological viruses.
      
 
      - 
        Cyber hygiene
        - Steps and practices that users should take to maintain system health
        and improve online security.
      
 
      - 
        Honeypot
        - Part of a system meant to look like an attractive target but actually
        helps detect and deflect attackers.
      
 
      - 
        Phoning home -
        When a system (e.g. stolen computer) secretly reports back to a third
        party other than the current possessor. The name is a reference to the
        movie E.T.
      
 
      - 
        Sandbox
        - A safe and isolated environment to test unverified programs that may
        contain malicious code.
      
 
      - 
        Trojan horse
        - Malware which misleads users of its true intent. The term is derived
        from the Ancient Greek story of the deceptive Trojan Horse.
      
 
    
    Libraries and Frameworks
    
      - 
        clooney - A
        JavaScript library implementing the actor model for concurrent
        computation. The term is a reference to George Clooney who is also an
        actor.
      
 
      - 
        Uglify - A JavaScript
        minifier. Removes everything that makes the code readable and pretty to
        make it smaller.
      
 
      - 
        uppy - A dog themed
        uploader component. The name is a blend of upload and
        puppy. It even comes with a crash recovery plugin called
        Golden Retriever.
      
 
    
    Machine Learning
    
      - 
        Confusion matrix
        - A tabular summary of a classifiers “confusion”, i.e. how often it
        thought to make correct predictions when it actually didn’t.
      
 
      - 
        Decision boundary
        - A boundary dividing the space of possible data points. Here you
        decide, everything on this side is SPAM, everything on that side is not.
      
 
    
    User Interface Design
    
      - 
        Breadcrumb
        - Navigational aid allowing users to keep track of their location within
        programs, documents, or websites. The term is a reference to the fairy
        tale Hansel and Gretel.
      
 
      - 
        Carousel
        - A kind of animated slideshow looping back on itself.
      
 
      - 
        Clipboard
        - Where you temporarily put files you are working with
        (i.e. the copy & paste buffer).
      
 
      - 
        Desktop -
        The metaphorical top of the user’s desk, upon which objects such as
        documents and folders of documents can be placed.
      
 
      - 
        Hamburger button
        - A button to toggle a menu. The associated icon resembles a hamburger.
      
 
      - 
        Optimistic UI
        - User interfaces that assume expensive operations will complete
        successfully thereby improving the perceived performance.
      
 
      - 
        Scrolling - Screen
        content is often less like a book with discrete pages and more like a
        continuous roll of parchment, i.e. a scroll.
      
 
    
    Theoretical Computer Science
    
      - 
        Clique problem
        - The problem of finding groups of mutual friends in a network of people
        with friendship relations. Or more general, finding complete subgraphs.
      
 
      - 
        Game of Life
        - A game world that showcases how astonishing complexity can arise from
        very simple ingredients.
      
 
      - 
        Oracle - A
        black box that magically gives answers even to undeciable questions like
        the halting problem.
      
 
      - 
        Pumping lemma
        - The fact that in some formal languages any sufficiently long string
        can be pumped with repetitions of its substring and the result
        stays in the same formal language.
      
 
    
    Other
    
      - 
        ACID vs. BASE
        - Acronyms describing competing database ideologies (aka. SQL
        vs. NoSQL).
      
 
      - 
        Bottleneck
        - A central part of a network/application that significantly limits
        throughput/performance and should ideally be eliminated.
      
 
      - 
        camelCase, snake_case, kebab-case
        - Different case styles where the name illustrates its appearance.
      
 
      - 
        Easter egg
        - A hidden feature especially in video games in reference to the Easter
        egg hunt.
      
 
      - 
        Floating point number
        - This representation can encode numbers at very different magnitudes
        with limited amount of digits by letting the radix point
        float instead of being fixed in place.
      
 
      - 
        Framework
        - In software architecture (like in actual architecture) frameworks
        provide basic structure to build upon that guide and constrain the
        further development.
      
 
      - 
        Garbage Collector
        - Part of a program that attempts to find and reclaim garbage pieces of
        memory not used anymore.
      
 
      - 
        Glue Code - Jenga
        and LEGO bricks don’t share the same interface but you can always glue
        them together.
      
 
      - 
        Heisenbug - A bug
        that seems to disappear or change when one tries to study it. It’s a pun
        on Werner Heisenberg who discovered that the act of observing quantum
        systems inevitably alters their state.
      
 
      - 
        Lazy evaluation
        - An evaluation stategy which suspends evaluation until it’s absolutly
        necessary and then never does it again.
      
 
      - 
        Magic -
        A magic program/piece of code is doing it’s job but nobody knows how.
        Like in reality, magic doesn’t actually exists. Once you understand it,
        it’s not magic anymore.
      
 
      - 
        Process starvation
        - A problem where a process is perpetually denied resources to do its
        work.
      
 
      - 
        Time travel debugging
        - Stepping back in time through source code to understand execution and
        sometimes even to change history.
      
 
      - 
        Tree shaking -
        Shake the dependency tree until all the dead parts are falling off and
        you end up with a nice lean tree.